The need for increased software application portability (i.e., the ability to execute a given software application on a variety of platforms having different hardware, operating systems, etc.), as well as the need to reduce time to market for independent software vendors (ISVs), have resulted in increased development and usage of managed runtime environments.
Managed runtime environments are typically implemented using a dynamic programming language such as, for example, JAVA—a registered mark of Sun Microsystems, Inc., C#, etc. A software engine (e.g., a Java Virtual Machine (JVM), Common Language Runtime (CLR), etc.), which is commonly referred to as a runtime environment, executes the dynamic program language instructions. The runtime environment interposes or interfaces between dynamic program language instructions (e.g., a JAVA program or source code) to be executed and the target execution platform (i.e., the hardware and operating system(s) of the computer executing the dynamic program) so that the dynamic pro-ram can be executed in a platform independent manner.
Dynamic program language instructions (e.g., JAVA instructions) are not statically compiled and linked directly into native or machine code for execution by the target platform (i.e., the operating system and hardware of the target processing system or platform). Instead, dynamic program language instructions are statically compiled into an intermediate language (e.g., bytecodes) and the intermediate language may interpreted or subsequently compiled by a just-in-time (JIT) compiler into native or machine code that can be executed by the target processing system or platform. Typically, the JIT compiler is provided by a runtime environment that is hosted by the operating system of a target processing platform such as, for example, a computer system. Thus, the runtime environment and, in particular, the JIT compiler, translates platform independent program instructions (e.g., JAVA bytecodes, C# bytecodes, etc.) into native code (i.e., machine code that can be executed by an underlying target processing system or platform).
To improve overall productivity, many dynamic programming languages and their supporting managed runtime environments provide infrastructure that enables concurrent programming techniques such as, for example, multi-threading to be employed. In particular, many dynamic programming languages provide synchronization features or operations that enable multiple concurrent threads of execution to share or access a given object and its variables without causing a conflict or contention. For example, in the case of a globally accessible object (i.e., a public object), the software designer typically assumes that conflict or contention can occur during runtime and includes appropriate synchronization operations within the object to prevent such a conflict or contention. In this manner, the software designer can guarantee that the globally accessible object is “thread safe” (i.e., can be employed in a multi-threading runtime environment without conflicts or contention).
Unfortunately, the processing overhead associated with object synchronization results in a significant reduction in execution time. For example, in the case of some well-known JAVA applications and benchmarks, synchronization overhead may consume between about ten to twenty percent of overall execution time. Furthermore, synchronization is usually employed as a safeguard to prevent contentions during runtime (particularly in the case of object libraries), regardless of whether such synchronization is actually required during runtime.
Known escape analysis techniques can be used to increase the overall execution speed of code including unnecessary synchronization. In general, known escape analysis techniques employ a whole program analysis that enables the removal of synchronization operations associated with non-global objects and global objects for which there will be no contention during runtime execution of the program. Known escape analysis techniques are based on a statically linked code model that assumes that no new classes of objects will be loaded during runtime. However, some popular programming languages such as, for example, JAVA and CLI (Common Language Infrastructure), provide a dynamic class loading feature that allows dynamic linking of methods or functions that are about to be called within a runtime context. In some cases, loading a class dynamically into a runtime environment that is executing a previously optimized program (e.g., a program from which synchronization has been removed in whole or in part), can cause the program to behave in an unsafe manner (e.g., data contention) or fail. While known escape analysis techniques based on a statically linked code model can be used to remove synchronization from statically linked code, these known techniques do not support the restoration of synchronization to previously desynchronized (i.e., optimized) code that subsequently requires synchronization due to the effects of a dynamically loaded class. Additionally, other open world features such as, for example, reflection and native methods can invalidate an escape analysis, thereby leading to unsafe execution conditions.